\documentclass{report}

\usepackage[utf8]{inputenc}
\usepackage[pdftex,bookmarks=true]{hyperref}
\usepackage{listings}
\usepackage{graphicx}
\usepackage{subfig}
\usepackage{float}
\usepackage[top=3cm, bottom=2.5cm, left=3cm, right=3cm]{geometry}

\renewcommand{\abstractname}{Sumário}
\renewcommand{\contentsname}{Conteúdo}
\renewcommand{\listtablename}{Lista de tabelas}
\renewcommand{\listfigurename}{Lista de figuras}
\renewcommand{\tablename}{Tabela}
\renewcommand{\figurename}{Imagem}
\renewcommand{\bibname}{Bibliografia}

\newcommand{\DocTitle}{Implementação de um Statement Concorrente}

\setcounter{tocdepth}{3}
\setcounter{secnumdepth}{3}

\captionsetup{justification=centering,font=small}

\lstset{language=Java, numbers=left, numberstyle=\tiny, numbersep=5pt}

\DeclareGraphicsExtensions{.pdf,.png,.jpg}

\pdfinfo {
  /Author   (Wilson Santos, 36288)
  /Title    (\DocTitle)
  /Subject  (Tese de Mestrado)
}


\begin{document}

% top matter

\title{\DocTitle}
\author{Wilson Santos, 36288 \texttt{$<$wilson.santos@ua.pt$>$}\\
  Universidade de Aveiro}
\maketitle

\begin{abstract}
A definição da API JDBC não prevê uma utilização concorrente dos serviços disponibilizados pelas várias interfaces que a constituem. Por isso, os drivers que implementam a API, não possuem suporte para um acesso concorrente. Neste documento é abordada uma solução para o acesso concorrente aos serviços disponibilizados pela interface \texttt{java.sql.Statement} relacionados com a execução de um conjunto de comandos SQL (\emph{batch}). No final da implementação, são realizados testes de desempenho que avaliam a sua performance em relação à implementação standard. 
\end{abstract}

\tableofcontents
\addcontentsline{toc}{section}{Conteúdo}

\listoftables
\addcontentsline{toc}{section}{Lista de tabelas}

\listoffigures
\addcontentsline{toc}{section}{Lista de figuras}

\pagebreak

\section*{Introdução}
\addcontentsline{toc}{section}{Introdução}
Neste documento é discutida a implementação concorrente dos serviços da interface \texttt{java.sql.Statement} relacionados com a execução de um conjunto de comandos SQL (\emph{batch}). Esta solução permite que vários threads trabalhem ao mesmo tempo sobre o mesmo objecto \emph{Statement}.
\\

Neste documento quando se fala de implementação nativa ou standard da \emph{Statement}, refere-se à implementação realizada pelo driver JDBC da Microsoft (\href{http://www.microsoft.com/downloads/en/details.aspx?FamilyID=a737000d-68d0-4531-b65d-da0f2a735707&displaylang=en}{Microsoft SQL Server JDBC Driver 3.0}).

\newpage

\section{Statement Concorrente}
Esta solução começa por fornecer uma interface que fornece serviços para a execução de um conjunto de comandos SQL:
\begin{itemize}
  \item \texttt{addBatch}, adiciona um comando SQL à lista de comandos do objecto \emph{Statement}.
  \item \texttt{clearBatch}, apaga a lista de comandos SQL.
  \item \texttt{executeBatch}, executa a lista de comandos SQL.
\end{itemize}

\begin{figure}[H]
  \caption{Diagrama de classes da classe \emph{EStatement}}
  \label{img:ers}
  \centering
  \includegraphics[width=15cm]{./diagrams/addBatch}
\end{figure}

Esta solução será identificada como \emph{EStatement}.

Para além deste três métodos, que existem na definição da API JDBC, foram adicionados dois métodos relacionados com o bloqueio do objecto, de modo a garantir acesso exclusivo (ver secção \ref{sec:block}).

\subsection{Bloqueio da \emph{statement}}
\label{sec:block}
Como foi mencionado anteriormente a interface de acesso à \emph{statement} (IStatement) fornece a funcionalidade de bloquear o acesso à \emph{statement}. Isto significa que é possível a um thread ter acesso exclusivo, podendo efectuar qualquer conjunto de operações sobre a \emph{statement}, sem existirem operações executadas por outros threads. Quando o thread já não necessitar de acesso exclusivo invoca a primitiva de desbloqueio.

\pagebreak


\section{Medição do desempenho}
Nesta secção é descrito o modo como foi medido o desempenho das soluções implementadas.
\\

Para avaliar o desempenho foi medido o tempo que uma quantidade de threads leva a inserir vários comandos SQL no \emph{batch} e a executá-lo.
Foram criados um \texttt{runnable} para executar essas tarefas sobre um objecto \emph{EStatement} e outro para executar sobre o objecto fornecido pela implementação do driver.
A Tabela \ref{tab:runnable} contém uma pequena descrição de cada tipo de \texttt{runnable} criado.

\begin{table}[H]
  \caption{Resumo dos \texttt{runnable} utilizados nas medições do desempenho}
  \label{tab:runnable}
  \centering
\begin{tabular}{| l | p{7.3cm} |}
  \hline
  EStatementRunnable     & runnable que utiliza um objecto \emph{EStatement} para executar o \emph{batch}. \\ \hline
  StatementRunnable      & runnable que utiliza a implementação standard para executar o \emph{batch}. \\ \hline
\end{tabular}
\end{table}

Os tempos medidos (ver Imagem \ref{img:Results}) correspondem à soma de dois valores: o tempo total que um número de threads demora a executar as tarefas indicadas pelo \texttt{runnable} (descrito na secção \ref{ref:executiontime}), e o tempo que é necessário para preparar o ambiente de execução dos threads (descrito na secção \ref{ref:setuptime}).

\subsection{Configuração dos testes}
As \emph{statements} usadas para criar os objectos do tipo ResultSet foram configuradas da seguinte forma:
\begin{itemize}
  \item tipo, \texttt{ResultSet.TYPE\_SCROLLABLE\_SENSITIVE}.
  \item concorrência, \texttt{ResultSet.CONCUR\_UPDATABLE}.
\end{itemize}

Os threads trabalharam sobre a tabela da Imagem \ref{img:testtable}. Essa tabela é limpa antes de todas as medições.

\begin{figure}[H]
  \caption{Estrutura da tabela de testes}
  \label{img:testtable}
  \centering
  \includegraphics[width=4cm]{./diagrams/dbTestData}
\end{figure}

\subsection{Tempo de preparação}
\label{ref:setuptime}

O tempo de preparação (setup) consiste no tempo que o código que prepara a execução dos threads demora a ser executado. Para todas as tarefas a contagem do tempo de preparação foi realizada da seguinte forma:

\begin{figure}[H]
  \caption{Contagem do tempo de preparação}
  \label{img:countSetup}
  \centering
  \includegraphics[width=8cm]{./diagrams/countSetup}
\end{figure}

~\\
Quando se usa a \textbf{implementação \emph{standard}} não é possível partilhar o objecto da \emph{statement} entre os threads. Por isso é necessário criar um objecto \emph{Statement} para cada thread.

\lstinputlisting[firstline=67,lastline=72,caption=Código de preparação para a Statement.,label=lst:setupstmt,frame=tb]{../../../src/ws/jdbc/concurrent/test/StatementConcurrentTest.java}

A classe \emph{ThreadManager} quando instanciada cria internamente uma lista de threads com tamanho igual a \texttt{numberOfThreads}, e a cada thread associa uma nova instância do \texttt{runnable} que é passado como segundo argumento para o construtor. O método \texttt{addLog} regista o tempo que o código demorou a ser executado.
\\

Cada \texttt{runnable} \emph{StatementRunnable} no seu construtor cria uma \emph{statement} só para si, a partir da ligação que lhe foi atribuída anteriormente, tal como demonstrado na Listagem \ref{lst:stmtconstructor}.

\lstinputlisting[firstline=28,lastline=32,caption=Construtor de um \emph{StatementRunnable}.,label=lst:stmtconstructor,frame=tb]{../../../src/ws/jdbc/concurrent/test/tasks/StatementRunnable.java}

~\\
No caso da \emph{\textbf{EStatement}} o objecto \emph{statement} pode ser partilhado, pelo que só é necessário um objecto \emph{statement} (linha 6 da Listagem \ref{lst:setupestmt}).

\lstinputlisting[firstline=55,lastline=62,caption=Código de preparação para o EStatement.,label=lst:setupestmt,frame=tb]{../../../src/ws/jdbc/concurrent/test/StatementConcurrentTest.java}

\subsection{Tempo de execução}
\label{ref:executiontime}

O tempo de execução corresponde ao tempo total que um número de threads demora a terminar a tarefa que lhes foi dada. A contagem do tempo de execução foi realizada da seguinte forma:

\begin{figure}[H]
  \caption{Contagem do tempo de execução}
  \label{img:countExecution}
  \centering
  \includegraphics[width=8cm]{./diagrams/countExecution}
\end{figure}

O código que efectua a contagem do tempo de execução é o seguinte:

\lstinputlisting[firstline=84,lastline=89,caption=Código de execução.,label=lst:countExecution,frame=tb]{../../../src/ws/jdbc/concurrent/test/StatementConcurrentTest.java}

A variável \texttt{tman} contém uma referência para uma instância da classe \emph{ThreadManager}

~\\
O código para realizar as tarefas encontra-se na Listagem \ref{lst:execution}.

\lstinputlisting[firstline=57,lastline=62,caption=Código executado pelos threads.,label=lst:execution,frame=tb]{../../../src/ws/jdbc/concurrent/test/tasks/StatementRunnable.java}

~\\
A variável \texttt{cycleCount} contém o número de vezes que o thread irá tentar adicionar os comandos ao \emph{batch}.

\newpage

\section{Resultados}
O teste de desempenho foi realizado num cenário cliente-servidor. Do lado do cliente correram os threads e do lado do servidor estava a base de dados, que atendia aos pedidos dos threads.

O cliente é numa máquina com o processador Intel SU4100 @1.3GHz, com 4.0GB de memória, sistema operativo Linux 2.6.32. O servidor estava a correr numa máquina virtual com 1.2GB de memória e sistema operativo Windows XP SP3. A comunicação entre os dois foi estabelecida usando uma interface \texttt{tap} no cliente e uma interface \emph{Bridged} no servidor.

As tabelas a seguir contêm as medições realizadas e refletem a média dos 10 melhores resultados, seleccionados de um conjunto de 25 amostras. Ao \emph{cycleCount} foi atribuído o valor 20.

Os valores da tabela seguinte apresenta os valores totais, isto é, tempo de preparação mais tempo de execução. Os valores de todas as tabelas encontram-se em \emph{milissegundos}.

\begin{figure}[H]
  \caption{Resultados das medições de desempenho - Execução}
  \label{img:Results}
  \centering
  \includegraphics[width=10cm]{./results/imgs/Results}
\end{figure}

\begin{figure}[H]
  \caption{Resultados das medições de desempenho - Preparação}
  \label{img:SetupResults}
  \centering
  \includegraphics[width=10cm]{./results/imgs/Setup}
\end{figure}

\subsection{Comparação}
Nesta secção serão efectuadas comparações entre os resultados medidos, de modo a avaliar as implementações na execução das diferentes tarefas.
\\

Nesta secção é realizada uma comparação entre \emph{statement standard} e \emph{EStatement}. Para isso efetuou-se o quociente entre os valores medidos para a \emph{statement standard} e os valores medidos para \emph{EStatement}. Os valores acima de '\textbf{1}' indicam que a solução concorrente implementada apresentou um desempenho superior à implementação \emph{standard}.
\\

\begin{figure}[H]
  \caption{Comparação entre \emph{statement standard} e \emph{EStatement}}
  \label{img:compExec}
  \centering
  \includegraphics[width=12cm]{./results/imgs/compExec}
\end{figure}

\pagebreak

\bibliography{mybib}{}
\addcontentsline{toc}{section}{Bibliografia}
\bibliographystyle{unsrt}

\end{document}
